home *** CD-ROM | disk | FTP | other *** search
/ InterCD 2000 September / september_2000.iso / intercd / root / ^Linux / cdrecord-1.8.1 / lib / comerr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-12-24  |  4.0 KB  |  210 lines
  1. /* @(#)comerr.c    1.21 99/12/24 Copyright 1985 J. Schilling */
  2. /*
  3.  *    Routines for printing command errors
  4.  *
  5.  *    Copyright (c) 1985 J. Schilling
  6.  */
  7. /*
  8.  * This program is free software; you can redistribute it and/or modify
  9.  * it under the terms of the GNU General Public License as published by
  10.  * the Free Software Foundation; either version 2, or (at your option)
  11.  * any later version.
  12.  *
  13.  * This program is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  * GNU General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU General Public License
  19.  * along with this program; see the file COPYING.  If not, write to
  20.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23. #include <mconfig.h>
  24. #include <stdio.h>
  25. #include <standard.h>
  26. #include <stdxlib.h>
  27. #include <vadefs.h>
  28. #include <strdefs.h>
  29. #ifndef    HAVE_STRERROR
  30. extern    char    *sys_errlist[];
  31. extern    int    sys_nerr;
  32. #endif
  33.  
  34. EXPORT    int    on_comerr    __PR((void (*fun)(int, void *), void *arg));
  35. EXPORT    void    comerr        __PR((const char *, ...));
  36. EXPORT    void    comerrno    __PR((int, const char *, ...));
  37. EXPORT    int    errmsg        __PR((const char *, ...));
  38. EXPORT    int    errmsgno    __PR((int, const char *, ...));
  39. LOCAL    int    _comerr        __PR((int, int, const char *, va_list));
  40. EXPORT    void    comexit        __PR((int));
  41. EXPORT    char    *errmsgstr    __PR((int));
  42.  
  43. typedef    struct ex {
  44.     struct ex *next;
  45.     void    (*func) __PR((int, void *));
  46.     void    *arg;
  47. } ex_t;
  48.  
  49. LOCAL    ex_t    *exfuncs;
  50.  
  51. EXPORT    int
  52. on_comerr(func, arg)
  53.     void    (*func) __PR((int, void *));
  54.     void    *arg;
  55. {
  56.     ex_t    *fp;
  57.  
  58.     fp = malloc(sizeof(*fp));
  59.     if (fp == NULL)
  60.         return (-1);
  61.  
  62.     fp->func = func;
  63.     fp->arg  = arg;
  64.     fp->next = exfuncs;
  65.     exfuncs = fp;
  66.     return (0);
  67. }
  68.  
  69. /* VARARGS1 */
  70. #ifdef    PROTOTYPES
  71. void comerr(const char *msg, ...)
  72. #else
  73. void comerr(msg, va_alist)
  74.     char    *msg;
  75.     va_dcl
  76. #endif
  77. {
  78.     va_list    args;
  79.  
  80. #ifdef    PROTOTYPES
  81.     va_start(args, msg);
  82. #else
  83.     va_start(args);
  84. #endif
  85.     (void)_comerr(TRUE, geterrno(), msg, args);
  86.     /* NOTREACHED */
  87.     va_end(args);
  88. }
  89.  
  90. /* VARARGS2 */
  91. #ifdef    PROTOTYPES
  92. void comerrno(int err, const char *msg, ...)
  93. #else
  94. void comerrno(err, msg, va_alist)
  95.     int    err;
  96.     char    *msg;
  97.     va_dcl
  98. #endif
  99. {
  100.     va_list    args;
  101.  
  102. #ifdef    PROTOTYPES
  103.     va_start(args, msg);
  104. #else
  105.     va_start(args);
  106. #endif
  107.     (void)_comerr(TRUE, err, msg, args);
  108.     /* NOTREACHED */
  109.     va_end(args);
  110. }
  111.  
  112. /* VARARGS1 */
  113. #ifdef    PROTOTYPES
  114. int errmsg(const char *msg, ...)
  115. #else
  116. int errmsg(msg, va_alist)
  117.     char    *msg;
  118.     va_dcl
  119. #endif
  120. {
  121.     va_list    args;
  122.     int    ret;
  123.  
  124. #ifdef    PROTOTYPES
  125.     va_start(args, msg);
  126. #else
  127.     va_start(args);
  128. #endif
  129.     ret = _comerr(FALSE, geterrno(), msg, args);
  130.     va_end(args);
  131.     return (ret);
  132. }
  133.  
  134. /* VARARGS2 */
  135. #ifdef    PROTOTYPES
  136. int errmsgno(int err, const char *msg, ...)
  137. #else
  138. int errmsgno(err, msg, va_alist)
  139.     int    err;
  140.     char    *msg;
  141.     va_dcl
  142. #endif
  143. {
  144.     va_list    args;
  145.     int    ret;
  146.  
  147. #ifdef    PROTOTYPES
  148.     va_start(args, msg);
  149. #else
  150.     va_start(args);
  151. #endif
  152.     ret = _comerr(FALSE, err, msg, args);
  153.     va_end(args);
  154.     return (ret);
  155. }
  156.  
  157. LOCAL int _comerr(exflg, err, msg, args)
  158.     int        exflg;
  159.     int        err;
  160.     const char    *msg;
  161.     va_list        args;
  162. {
  163.     char    errbuf[20];
  164.     char    *errnam;
  165.     char    *prognam = get_progname();
  166.     
  167.     if (err < 0) {
  168.         error("%s: %r", prognam, msg, args);
  169.     } else {
  170.         errnam = errmsgstr(err);
  171.         if (errnam == NULL) {
  172.             (void)sprintf(errbuf, "Error %d", err);
  173.             errnam = errbuf;
  174.         }
  175.         error("%s: %s. %r", prognam, errnam, msg, args);
  176.     }
  177.     if (exflg) {
  178.         comexit(err);
  179.         /* NOTREACHED */
  180.     }
  181.     return(err);
  182. }
  183.  
  184. EXPORT void
  185. comexit(err)
  186.     int    err;
  187. {
  188.     while (exfuncs) {
  189.         (*exfuncs->func)(err, exfuncs->arg);
  190.         exfuncs = exfuncs->next;
  191.     }
  192.     exit(err);
  193.     /* NOTREACHED */
  194. }
  195.  
  196. EXPORT char *
  197. errmsgstr(err)
  198.     int    err;
  199. {
  200. #ifdef    HAVE_STRERROR
  201.     return (strerror(err));
  202. #else
  203.     if (err < 0 || err >= sys_nerr) {
  204.         return (NULL);
  205.     } else {
  206.         return (sys_errlist[err]);
  207.     }
  208. #endif
  209. }
  210.